const { Contact, CrmCustomer, User } = require('../models');
const config = require('../config');
const { Op } = require('sequelize');
const json2csv = require('json2csv').Parser;
const db = require('../models');

/**
 * 获取联系人列表
 */
exports.getContacts = async (req, res) => {
  try {
    const contacts = await Contact.findAll({
      include: [
        {
          model: CrmCustomer,
          as: 'crmInfo',
          required: false
        }
      ]
    });
    
    // 根据用户角色处理联系人信息
    const processedContacts = contacts.map(contact => {
      const basic = {
        id: contact.id,
        name: contact.name,
        whatsappId: contact.whatsappId,
        profilePicUrl: contact.profilePicUrl,
        lastActivity: contact.lastActivity,
        crmInfo: contact.crmInfo
      };
      
      // 如果是管理员，可以看到真实电话号码
      if (req.user.role === config.roles.ADMIN) {
        return {
          ...basic,
          phone: contact.phone ? Contact.decryptPhone(contact.phone, process.env.ENCRYPTION_KEY) : null
        };
      }
      
      // 销售人员看不到真实电话号码
      return basic;
    });
    
    res.json(processedContacts);
  } catch (error) {
    console.error('获取联系人列表出错:', error);
    res.status(500).json({ message: '服务器内部错误', error: error.message });
  }
};

/**
 * 获取单个联系人详情
 */
exports.getContact = async (req, res) => {
  try {
    const { id } = req.params;
    
    const contact = await Contact.findByPk(id, {
      include: [
        {
          model: CrmCustomer,
          as: 'crmInfo'
        }
      ]
    });
    
    if (!contact) {
      return res.status(404).json({ message: '联系人不存在' });
    }
    
    // 根据用户角色处理联系人信息
    const processedContact = {
      id: contact.id,
      name: contact.name,
      whatsappId: contact.whatsappId,
      profilePicUrl: contact.profilePicUrl,
      lastActivity: contact.lastActivity,
      crmInfo: contact.crmInfo
    };
    
    // 如果是管理员，可以看到真实电话号码
    if (req.user.role === config.roles.ADMIN && contact.phone) {
      processedContact.phone = Contact.decryptPhone(contact.phone, process.env.ENCRYPTION_KEY);
    }
    
    res.json(processedContact);
  } catch (error) {
    console.error('获取联系人详情出错:', error);
    res.status(500).json({ message: '服务器内部错误', error: error.message });
  }
};

/**
 * 更新CRM信息
 */
exports.updateCrmInfo = async (req, res) => {
  try {
    const { id } = req.params;
    const crmData = req.body;
    
    // 查找现有CRM客户
    let customer = await db.CrmCustomer.findOne({
      where: { id }
    });
    
    if (customer) {
      // 更新现有客户
      await customer.update(crmData);
    } else {
      res.status(404).json({ message: '未找到CRM客户' });
      return;
    }
    
    res.json({ message: 'CRM客户信息已更新', customer });
  } catch (error) {
    console.error('更新CRM客户失败:', error);
    res.status(500).json({ message: '更新CRM客户失败', error: error.message });
  }
};

/**
 * 获取所有CRM客户
 */
exports.getAllCrmCustomers = async (req, res) => {
  try {
    console.log('开始执行getAllCrmCustomers控制器方法');
    
    // 解析分页参数
    const page = parseInt(req.query.page) || 1;
    const pageSize = parseInt(req.query.pageSize) || 10;
    const offset = (page - 1) * pageSize;
    
    console.log(`获取CRM客户列表: 页码=${page}, 每页=${pageSize}`);
    
    // 检查数据库连接状态
    try {
      await db.sequelize.authenticate();
      console.log('数据库连接正常');
    } catch (dbErr) {
      console.error('数据库连接异常:', dbErr);
      return res.status(500).json({ 
        message: '数据库连接失败', 
        error: dbErr.message 
      });
    }
    
    // 解析排序参数 - 添加更多错误处理
    let order = [['updatedAt', 'DESC']]; // 默认排序
    
    try {
      if (req.query.sortField && req.query.sortOrder) {
        // 处理特殊的排序字段，如嵌套字段
        if (req.query.sortField.includes('.')) {
          const [model, field] = req.query.sortField.split('.');
          order = [[db.Sequelize.literal(`"${model}"."${field}"`), req.query.sortOrder]];
        } else {
          order = [[req.query.sortField, req.query.sortOrder]];
        }
      }
    } catch (sortErr) {
      console.error('排序参数处理错误:', sortErr);
      // 继续使用默认排序，不中断请求
      order = [['updatedAt', 'DESC']];
    }
    
    // 简化查询 - 减少JOIN复杂性
    console.log('准备执行简化的CRM客户查询...');
    
    try {
      // 先获取总记录数 - 单独查询以避免复杂计算
      const count = await db.CrmCustomer.count();
      console.log(`CRM客户总数: ${count}`);
      
      // 然后获取分页数据 - 如果出错，可以尝试更简单的查询
      let customers = [];
      try {
        customers = await db.CrmCustomer.findAll({
          order,
          offset,
          limit: pageSize
        });
        console.log(`成功获取 ${customers.length} 条客户记录`);
      } catch (findErr) {
        console.error('查询客户数据出错:', findErr);
        return res.status(500).json({ 
          message: '查询客户数据失败', 
          error: findErr.message 
        });
      }
      
      // 获取客户ID数组
      const customerIds = customers.map(c => c.id);
      
      // 现在单独获取联系人数据
      let contacts = [];
      try {
        if (customerIds.length > 0) {
          contacts = await db.Contact.findAll({
            where: {
              id: {
                [db.Sequelize.Op.in]: customers.map(c => c.contactId).filter(Boolean)
              }
            }
          });
        }
        console.log(`获取了 ${contacts.length} 个相关联系人`);
      } catch (contactErr) {
        console.error('获取联系人数据出错:', contactErr);
        // 继续处理，使用空联系人数据
      }
      
      // 构建联系人查找表
      const contactMap = {};
      contacts.forEach(contact => {
        contactMap[contact.id] = contact;
      });
      
      // 手动组装数据
      const result = customers.map(customer => {
        const contact = customer.contactId ? contactMap[customer.contactId] : null;
        return {
          ...customer.toJSON(),
          contact: contact ? contact.toJSON() : null
        };
      });
      
      // 计算各种状态的客户数量
      const stats = await getCustomerStats();
      
      console.log('CRM客户数据查询完成，准备返回结果');
      
      // 返回统一格式的数据
      return res.json({
        data: result,
        total: count,
        stats,
        page,
        pageSize
      });
    } catch (mainErr) {
      console.error('执行主查询出错:', mainErr);
      
      // 尝试退回到最简单的查询
      console.log('尝试使用备用查询方式...');
      
      try {
        const basicCustomers = await db.CrmCustomer.findAll({
          attributes: ['id', 'name', 'phone', 'status', 'createdAt', 'updatedAt'],
          limit: pageSize
        });
        
        // 返回简化结果
        return res.json({
          data: basicCustomers,
          total: basicCustomers.length,
          stats: {
            total: basicCustomers.length,
            leads: 0,
            prospects: 0,
            customers: 0,
            inactive: 0
          },
          page,
          pageSize,
          isBackupData: true
        });
      } catch (backupErr) {
        console.error('备用查询也失败:', backupErr);
        throw mainErr; // 抛出原始错误以便被外部错误处理器捕获
      }
    }
  } catch (error) {
    console.error('获取CRM客户失败:', error);
    
    // 详细的错误信息
    const errorDetails = {
      message: error.message,
      stack: error.stack,
      name: error.name
    };
    
    // 记录SQL错误
    if (error.sql) {
      console.error('SQL错误:', {
        sql: error.sql,
        parameters: error.parameters
      });
      errorDetails.sql = error.sql;
    }
    
    res.status(500).json({ 
      message: '获取CRM客户失败', 
      error: errorDetails
    });
  }
};

/**
 * 获取客户统计信息
 */
const getCustomerStats = async () => {
  try {
    // 获取总数
    const total = await db.CrmCustomer.count();
    
    // 获取各状态的数量
    const leads = await db.CrmCustomer.count({ where: { status: 'lead' } });
    const prospects = await db.CrmCustomer.count({ where: { status: 'prospect' } });
    const customers = await db.CrmCustomer.count({ where: { status: 'customer' } });
    const inactive = await db.CrmCustomer.count({ where: { status: 'inactive' } });
    
    return {
      total,
      leads,
      prospects,
      customers,
      inactive
    };
  } catch (error) {
    console.error('获取客户统计失败:', error);
    return {
      total: 0,
      leads: 0,
      prospects: 0,
      customers: 0,
      inactive: 0
    };
  }
};

/**
 * 更新CRM客户状态
 */
exports.updateCrmStatus = async (req, res) => {
  try {
    const { id } = req.params;
    const { status } = req.body;
    
    if (!['lead', 'prospect', 'customer', 'inactive'].includes(status)) {
      return res.status(400).json({ message: '无效的状态值' });
    }
    
    const crmCustomer = await CrmCustomer.findByPk(id);
    
    if (!crmCustomer) {
      return res.status(404).json({ message: 'CRM客户不存在' });
    }
    
    await crmCustomer.update({ status });
    
    res.json({
      success: true,
      message: 'CRM客户状态已更新',
      status
    });
  } catch (error) {
    console.error('更新CRM客户状态出错:', error);
    res.status(500).json({ message: '服务器内部错误', error: error.message });
  }
};

/**
 * 删除CRM客户
 */
exports.deleteCrmCustomer = async (req, res) => {
  try {
    const { id } = req.params;
    
    const crmCustomer = await CrmCustomer.findByPk(id);
    
    if (!crmCustomer) {
      return res.status(404).json({ message: 'CRM客户不存在' });
    }
    
    await crmCustomer.destroy();
    
    res.json({
      success: true,
      message: 'CRM客户已删除'
    });
  } catch (error) {
    console.error('删除CRM客户出错:', error);
    res.status(500).json({ message: '服务器内部错误', error: error.message });
  }
};

/**
 * 添加新CRM客户
 */
exports.addCrmCustomer = async (req, res) => {
  try {
    const { name, phone, product, quantity, location, notes, contactId, whatsappId } = req.body;
    
    // 验证必填字段
    if (!name) {
      return res.status(400).json({ message: '客户名称不能为空' });
    }
    
    // 查找或创建CRM客户
    let [customer, created] = await db.CrmCustomer.findOrCreate({
      where: {
        [db.Sequelize.Op.or]: [
          { contactId: contactId || null },
          { phone: phone || null }
        ]
      },
      defaults: {
        name,
        phone,
        product,
        quantity,
        location,
        notes,
        contactId,
        whatsappId
      }
    });
    
    // 如果客户已存在，更新信息
    if (!created) {
      await customer.update({
        name,
        phone,
        product,
        quantity,
        location,
        notes,
        whatsappId
      });
    }
    
    // 如果有ContactId，更新Contact表中的CRM标记
    if (contactId) {
      const contact = await db.Contact.findByPk(contactId);
      if (contact) {
        await contact.update({
          inCrm: true,
          crmId: customer.id,
          crmInfo: `${name} ${quantity || ''} ${product || ''} ${location || ''}`.trim()
        });
      }
    }
    
    res.status(created ? 201 : 200).json({
      message: created ? '已添加到CRM系统' : '已更新CRM信息',
      id: customer.id,
      name: customer.name,
      created
    });
  } catch (error) {
    console.error('添加CRM客户失败:', error);
    res.status(500).json({ message: '添加CRM客户失败', error: error.message });
  }
};

/**
 * 导出CRM数据
 */
exports.exportCrmData = async (req, res) => {
  try {
    const customers = await db.CrmCustomer.findAll({
      include: [{
        model: db.Contact,
        as: 'contact'
      }]
    });
    
    // 构建CSV头
    const csvHeader = 'ID,姓名,电话,产品,数量,地区,备注,创建时间,更新时间\n';
    
    // 构建CSV内容
    const csvContent = customers.map(customer => {
      return `${customer.id},"${customer.name}","${customer.phone || ''}","${customer.product || ''}","${customer.quantity || ''}","${customer.location || ''}","${customer.notes || ''}","${customer.createdAt}","${customer.updatedAt}"`;
    }).join('\n');
    
    // 设置响应头
    res.setHeader('Content-Type', 'text/csv');
    res.setHeader('Content-Disposition', 'attachment; filename=crm-customers.csv');
    
    // 发送CSV数据
    res.send(csvHeader + csvContent);
  } catch (error) {
    console.error('导出CRM数据失败:', error);
    res.status(500).json({ message: '导出CRM数据失败', error: error.message });
  }
};

/**
 * 获取CRM统计数据
 */
exports.getCrmStats = async (req, res) => {
  try {
    // 按状态统计
    const statusStats = await CrmCustomer.findAll({
      attributes: [
        'status',
        [sequelize.fn('COUNT', sequelize.col('id')), 'count']
      ],
      group: ['status']
    });
    
    // 按来源统计
    const sourceStats = await CrmCustomer.findAll({
      attributes: [
        'source',
        [sequelize.fn('COUNT', sequelize.col('id')), 'count']
      ],
      where: {
        source: {
          [Op.not]: null,
          [Op.ne]: ''
        }
      },
      group: ['source']
    });
    
    // 按行业统计
    const industryStats = await CrmCustomer.findAll({
      attributes: [
        'industry',
        [sequelize.fn('COUNT', sequelize.col('id')), 'count']
      ],
      where: {
        industry: {
          [Op.not]: null,
          [Op.ne]: ''
        }
      },
      group: ['industry']
    });
    
    // 最近添加的客户
    const recentCustomers = await CrmCustomer.findAll({
      include: [
        {
          model: Contact
        }
      ],
      order: [['createdAt', 'DESC']],
      limit: 5
    });
    
    res.json({
      statusStats,
      sourceStats,
      industryStats,
      recentCustomers
    });
  } catch (error) {
    console.error('获取CRM统计数据出错:', error);
    res.status(500).json({ message: '服务器内部错误', error: error.message });
  }
};

// 辅助函数 - 状态翻译
function translateStatus(status) {
  const statusMap = {
    'lead': '潜在线索',
    'prospect': '有效潜客',
    'customer': '客户',
    'inactive': '不活跃'
  };
  
  return statusMap[status] || status;
}

// 辅助函数 - 格式化日期
function formatDate(date) {
  if (!date) return '';
  
  const d = new Date(date);
  return `${d.getFullYear()}-${padZero(d.getMonth() + 1)}-${padZero(d.getDate())} ${padZero(d.getHours())}:${padZero(d.getMinutes())}`;
}

// 辅助函数 - 补零
function padZero(num) {
  return num < 10 ? `0${num}` : num;
}

/**
 * 搜索联系人
 */
exports.searchContacts = async (req, res) => {
  try {
    const { q } = req.query;
    const { Contact } = require('../models');
    const { Op } = require('sequelize');
    
    // 如果查询参数不足，返回空数组
    if (!q || q.length < 2) {
      return res.json([]);
    }
    
    // 搜索联系人 - 匹配姓名、电话号码或WhatsappID
    const contacts = await Contact.findAll({
      where: {
        [Op.or]: [
          { name: { [Op.like]: `%${q}%` } },
          { phone: { [Op.like]: `%${q}%` } },
          { whatsappId: { [Op.like]: `%${q}%` } }
        ]
      },
      limit: 10
    });
    
    // 格式化联系人数据
    const formattedContacts = contacts.map(contact => ({
      id: contact.id,
      name: contact.name || (contact.whatsappId ? contact.whatsappId.split('@')[0] : '未知联系人'),
      phoneNumber: contact.phone,
      profilePicUrl: contact.profilePicUrl,
      status: contact.status || 'offline',
      lastSeen: contact.lastActivity
    }));
    
    res.json(formattedContacts);
  } catch (error) {
    console.error('搜索联系人失败:', error);
    res.status(500).json({ message: '服务器内部错误', error: error.message });
  }
};

/**
 * 获取最近联系人
 */
exports.getRecentContacts = async (req, res) => {
  try {
    // 使用正确导入的模型
    const { Contact } = require('../models');
    const { Op } = require('sequelize');
    
    // 获取最近有消息的联系人，按最后消息时间排序
    let recentContacts = [];
    
    try {
      // 尝试使用lastMessageAt字段查询
      recentContacts = await Contact.findAll({
        order: [['lastMessageAt', 'DESC']],
        limit: 10,
        where: {
          lastMessageAt: {
            [Op.ne]: null
          }
        }
      });
    } catch (fieldError) {
      console.error('查询最近联系人失败，可能是字段不存在:', fieldError);
      // 如果上面的查询失败，可能是因为字段不存在
      // 获取所有联系人作为备选
      recentContacts = await Contact.findAll({
        order: [['updatedAt', 'DESC']],
        limit: 10
      });
    }
    
    // 处理返回数据
    const formattedContacts = recentContacts.map(contact => ({
      id: contact.id,
      name: contact.name || (contact.whatsappId ? contact.whatsappId.split('@')[0] : '未知联系人'),
      phoneNumber: contact.phone,
      profilePicUrl: contact.profilePicUrl,
      lastMessageTime: contact.lastMessageAt || contact.updatedAt,
      status: contact.status || 'offline',
      lastMessage: contact.lastMessageText || '没有最近消息',
      time: contact.lastMessageAt ? formatTime(contact.lastMessageAt) : '',
      unread: 0,
      hasSensitive: false
    }));
    
    res.json(formattedContacts);
  } catch (error) {
    console.error('获取最近联系人失败:', error);
    res.status(500).json({ message: '服务器内部错误', error: error.message });
  }
};

// 辅助函数：格式化时间
function formatTime(date) {
  if (!date) return '';
  
  const now = new Date();
  const messageDate = new Date(date);
  
  // 如果是今天的消息，显示时间
  if (messageDate.toDateString() === now.toDateString()) {
    return messageDate.toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' });
  }
  
  // 如果是昨天的消息，显示"昨天"
  const yesterday = new Date(now);
  yesterday.setDate(now.getDate() - 1);
  if (messageDate.toDateString() === yesterday.toDateString()) {
    return '昨天';
  }
  
  // 否则显示日期
  return messageDate.toLocaleDateString();
}

/**
 * 获取消息类型显示名称
 */
function getMessageTypeDisplay(type) {
  const typeMap = {
    'text': '文本',
    'image': '图片',
    'video': '视频',
    'audio': '语音',
    'document': '文档',
    'location': '位置',
    'contact': '联系人'
  };
  
  return typeMap[type] || type;
}

/**
 * 更新客户评分
 */
exports.updateCustomerRating = async (req, res) => {
  try {
    const { id } = req.params;
    const { rating } = req.body;
    
    // 验证评分范围
    const ratingValue = parseInt(rating);
    if (isNaN(ratingValue) || ratingValue < 0 || ratingValue > 5) {
      return res.status(400).json({ message: '评分必须是0到5之间的整数' });
    }
    
    // 查找客户
    const customer = await db.CrmCustomer.findByPk(id);
    
    if (!customer) {
      return res.status(404).json({ message: '客户不存在' });
    }
    
    // 更新评分
    await customer.update({ rating: ratingValue });
    
    res.json({
      success: true,
      message: '客户评分已更新',
      rating: ratingValue
    });
  } catch (error) {
    console.error('更新客户评分失败:', error);
    res.status(500).json({ message: '更新客户评分失败', error: error.message });
  }
};

/**
 * 批量删除客户
 */
exports.batchDeleteCustomers = async (req, res) => {
  try {
    const { ids } = req.body;
    
    if (!Array.isArray(ids) || ids.length === 0) {
      return res.status(400).json({ message: '无效的客户ID列表' });
    }
    
    // 批量删除
    const result = await db.CrmCustomer.destroy({
      where: {
        id: {
          [db.Sequelize.Op.in]: ids
        }
      }
    });
    
    res.json({
      success: true,
      message: `成功删除${result}个客户`,
      count: result
    });
  } catch (error) {
    console.error('批量删除客户失败:', error);
    res.status(500).json({ message: '批量删除客户失败', error: error.message });
  }
}; 